/**
 * @file mainDoc.hpp
 *
 * @date 12/02/2012
 * @author Tales 
 *
 * This file is intended only to have general documentation notes.
 */

/**
 * @mainpage
 *
 * The Wolf project's aim is to make an intuitive and flexible game engine. It
 *  looks like tool box with several useful classes. We also aim to have a good
 *  performance, perhaps it is not our main aim.
 *
 * We want to give to you freedom to do everything you want the way you want, we
 *  also want to help the development became more easier any quickly and When these
 *  principles collides, we try to provide both ways.
 *
 * This documentation primary aim is to support the library development and test,
 *  but we intend to do use it as an effective user guide and even a quick start
 *  material.
 *
 * Check our GoogleCode page to see more high level documentation. We should
 *  have tutorials there.
 *
 * @todo create the link to our GoogleCodePage.
 *
 * These pages help to understand as it works:
 *  - @subpage dependencies The libraries you should have to compile/run the Wolf Engine.
 *  - @subpage howitworks How it works.
 *
 * It has the following modules:
 *  - @ref engineMod "Engine" (the core classes);
 *  - @ref gameMod "Game Framework" (The application classes, used to control the program flow)
 *  - @ref errorsMod "Errors";
 *  - @ref utilsMod "Utilities" (color, rect, graphics);
 *    - @ref fontsMod "Fonts";
 *      - @ref bitmatFontMod "Bitmap Fonts";
 *  - @ref stdMod "Standard Framework" (opposed to console. It is single threaded and more efficient, but difficult to use);
 *    - @ref actorsMod "Actors";
 *      - @ref eventsMod "Events";
 *  - @ref consoleMod "Console Framework" (easy to use, because it uses threads to simulate a procedural environment);
 *  @todo complete the modules list and create groups for each one. (the @ defgroup command...)
 **/

/**
 * @page howitworks How it works
 *
 * We have a main class, called Engine, that controls the program flow. You can
 *  oversee its operation if you want to. In fact, the Engine expects you initialize
 *  the SDL and related libraries, instantiate the Engine and create the screen surface
 *  (and pass it to engine). You also has to check if the engine is running and call
 *  a frame.
 *
 * As the initialization is boring to code, we provide the helper Engine::prepare() method.
 *  This method initializes the SDL and all necessaries libraries (see @ref dependencies)
 *  and you can skip this task.
 *
 * Other important helper is the Engine::setVideoMode(). It is smaller than prepare() but
 *  it take the responsibility to call SDL_SetVideoMode() and use the result as screen
 *  surface (that generally is the expected by user).
 *
 * Using the helpers, the smallest piece of code capable to run would be like this:
 * @code
 * int main(int argc, const char **argv){
 *   Engine::prepare(); //Initialize SDL and stuff
 *   Engine myEngine(); //Create our engine
 *   engine.setVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP); //Select the video mode.
 *   engine.start(); //Start the engine
 *   while (engine.isRunning()) //Tests if it is running
 *   	engine.doFrame(); //Performs a frame.
 * }
 * @endcode
 * It's right, six lines to go.
 *
 * @todo Explain how the frames works and give some hints about the layers and actors
 */

/**
 * @page dependencies Dependencies
 *
 * It depends mainly of SDL libraries (http://libsdl.org). It needs it installed to
 *  compile and to use as DLL. Also, the SDL.dll (on windows) or SDL.so are needed
 *  in order to run.
 *
 * The SDL_ttf, SDL_image and SDL_gfx are also necessary to compile the library, but not to
 *  use it. To run, obviously it need their respective .dll's (or .so's).
 *
 */

/**
 * @namespace wolf
 * @brief The main namespace of the engine. All the classes are inside it.
 *  It is only used to avoid name collision with other framework.
 *
 **/
